home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1999 July: Mac OS SDK / Dev.CD Jul 99 SDK1.toast / Development Kits / Mac OS / MacX25 / MacX25 Developer's Kit / MacX25_Interfaces / CIncludes / standard.h < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-21  |  13.1 KB  |  347 lines  |  [TEXT/MPS ]
  1. /* ******************************************************************************************** */
  2. /* *                                                                                          * */
  3. /* *                      "MPW C 3.0" Version                                                 * */
  4. /* *                                                                                          * */
  5. /* ******************************************************************************************** */
  6.  
  7. #ifndef _standard_h_
  8.  
  9.  
  10. /* ******************************************************************************************** */
  11. /* *                                                                                          * */
  12. /* *    The definitions that follow are what is considered to be the standard UNIX            * */
  13. /* *    definitions.                                                                          * */
  14. /* *                                                                                          * */
  15. /* ******************************************************************************************** */
  16.  
  17.  
  18.       
  19. typedef     Boolean             boolean;
  20.  
  21. /*
  22. **  Abbreviated type Definitions
  23. */
  24.  
  25. typedef     unsigned char       uchar;
  26. typedef     unsigned short      ushort;
  27. typedef     unsigned int        uint;
  28. typedef     unsigned long       ulong;
  29.  
  30. /*
  31. **  Coverup a Compiler Hole
  32. */
  33.  
  34. #define _LINE_      0
  35. #define _FILE_      "????"
  36.  
  37.  
  38. /* ******************************************************************************************** */
  39. /* *                                                                                          * */
  40. /* *    Clister definitions.                                                                  * */
  41. /* *                                                                                          * */
  42. /* ******************************************************************************************** */
  43.  
  44. #ifndef _EJECT
  45. #define _EJECT
  46. #endif  _EJECT
  47.  
  48. #ifndef _PAGE
  49. #define _PAGE
  50. #endif  _PAGE
  51.  
  52. #ifndef _SPACE
  53. #define _SPACE(line_count)
  54. #endif  _SPACE
  55.  
  56. #ifndef _TITLE
  57. #define _TITLE(title_string)
  58. #endif  _TITLE
  59.  
  60. #ifndef _SUBTITLE
  61. #define _SUBTITLE(subtitle_string)
  62. #endif  _SUBTITLE
  63.  
  64.  
  65. /* ******************************************************************************************** */
  66. /* *                                                                                          * */
  67. /* *    The definitions that follow are extensions to the "normal" UNIX definitions.  To      * */
  68. /* *    allow maximum compatability, iff "uxix" is defined, the definitions that follow       * */
  69. /* *    will not be included.                                                                 * */
  70. /* *                                                                                          * */
  71. /* ******************************************************************************************** */
  72.  
  73. #ifndef unix
  74.  
  75. /*
  76. **  Boolean and Special Functions
  77. */
  78.  
  79. #define     and             &&                                  /* Boolean "and"                */
  80. #define     or              ||                                  /* Boolean "or"                 */
  81. #define     not             !                                   /* Boolean "not"                */
  82. #define     mod             %                                   /* Modular Division             */
  83.  
  84. /*
  85. **  Logical Functions
  86. */
  87.  
  88. #define     bit_and         &                                   /* Logical (bit) "and"          */
  89. #define     bit_or          |                                   /* Logical (bit) "or"           */
  90. #define     bit_eor         ^                                   /* Logical (bit) "eor"          */
  91. #define     bit_not         ~                                   /* Logical (bit) "not"          */
  92.  
  93. /*
  94. **  Null Pointers
  95. */
  96.  
  97. #undef      NULL
  98. #define     NULL            ((char *) 0)                        /* Null String Pointer          */
  99. #define     NIL             ((void *) 0)                        /* Generalized Null Pointer     */
  100.  
  101. /*
  102. **  Character / String Constants    
  103. */
  104.  
  105. #define     EOS             '\0'                                /* end-of-string terminator     */
  106.  
  107. /*
  108. **  Convenient Coding Macros    
  109. */
  110.  
  111. #define     forever         for(;;)
  112.  
  113. #define     iter(i,max)     for(i=0;i<max,i++)
  114.  
  115. #define     repeat          do
  116. #define     until(x)        while(!(x))
  117.  
  118. #define     ifnot(x)        if(!(x))
  119.  
  120. #define     abs(a)          (((a)>0)?(a):(-a))                  /* caution - side effects       */
  121. #define     max(a,b)        (((a)>(b))?(a):(b))                 /* caution - side effects       */
  122. #define     min(a,b)        (((a)<(b))?(a):(b))                 /* caution - side effects       */
  123.  
  124. /*  Returns number of elements in an array                                                      */
  125.  
  126. #define     countof(a)      (sizeof(a)/sizeof((a)[0]))
  127.  
  128. /*  Returns a pointer to the first element in an array                                          */
  129.  
  130. #define     startp(a)       (&(a)[0])
  131.  
  132. /*  Returns a pointer to the last element in an array                                           */
  133.  
  134. #define     endp(a)         (&(a)[(sizeof(a)/sizeof((a)[0]))-1])
  135.  
  136. /*  Returns an offset within a typedef to a member of the typedef                               */
  137.  
  138. #define     offsetof(typedef,member)    ((long)&(((typedef*)0)->member))
  139.  
  140. /* +------------------------------------------------------------------------------------------+ */
  141. /* |                                                                                          | */
  142. /* |    The following character handling macros parallel the ANSI-C character handling        | */
  143. /* |    functions defined in <ctype.h>.  These macros may be more efficient than subroutine   | */
  144. /* |    calls, but have the drawback of having side effects ( is_digit(*p++) will increment   | */
  145. /* |    p twice ).  To avoid conflict with the ANSI-C functions, these macros have an '_'     | */
  146. /* |    character in their names; the ANSI-C functions have no '_' characters.                | */
  147. /* |                                                                                          | */
  148. /* +------------------------------------------------------------------------------------------+ */
  149.         
  150. #define     to_upper(x)     ((((x)>='a')&&((x)<='z'))?((x)+'A'-'a'):(x))
  151. #define     to_lower(x)     ((((x)>='A')&&((x)<='Z'))?((x)+'a'-'A'):(x))
  152.  
  153. #define     is_upper(x)     (((x)>='a')&&((x)<='z'))
  154. #define     is_lower(x)     (((x)>='A')&&((x)<='Z'))
  155. #define     is_alpha(x)     (is_upper(x)||is_lower(x))
  156. #define     is_digit(x)     (((x)>='0')&&((x)<='9'))
  157. #define     is_alnum(x)     (is_upper(x)||is_lower(x)||is_digit(x))
  158. #define     is_xdigit(x)    ((((x)>='0')&((x)<='9'))||(((x)>='a')&((x)<='f'))||(((x)>='A')&((x)<='F')))
  159. #define     is_space(x)     (((x)==' ')||((x)=='\f')||((x)=='\n')||((x)=='\r')||((x)=='\t')||((x)=='\v'))
  160.  
  161. /*
  162. **  Routine / Variable Descriptions
  163. */
  164.  
  165. #define     global      extern
  166. #define     import      extern
  167. #define     export      
  168. #define     internal    static
  169. #define     local       static
  170.  
  171. /*
  172. **  Prioritized General Register Assignments
  173. */
  174. #define     register_01     register
  175. #define     register_02     register
  176. #define     register_03     register
  177. #define     register_04     register
  178. #define     register_05     register
  179. #define     register_06
  180. #define     register_07
  181. #define     register_08
  182.  
  183. /*
  184. **  Prioritized Data Register Assignments
  185. */
  186. #define     register_D01    register
  187. #define     register_D02    register
  188. #define     register_D03    register
  189. #define     register_D04    register
  190. #define     register_D05    register
  191. #define     register_D06
  192. #define     register_D07
  193. #define     register_D08
  194.  
  195. /*
  196. **  Prioritized Address (Pointer) Register Assignments
  197. */
  198. #define     register_A01    register
  199. #define     register_A02    register
  200. #define     register_A03
  201. #define     register_A04
  202. #define     register_A05
  203. #define     register_A06
  204. #define     register_A07
  205. #define     register_A08
  206.  
  207.  
  208. /*
  209. **  Standard Type Definitions
  210. */
  211.  
  212. typedef     unsigned char       u_int_08;
  213. typedef     unsigned int        u_int_16;
  214. typedef     unsigned long int   u_int_32;
  215.  
  216. typedef              char       s_int_08;
  217. typedef              int        s_int_16;
  218. typedef              long int   s_int_32;
  219.  
  220. /*
  221. **  Standard Coercion Definitions
  222. */
  223.  
  224. typedef     union   {
  225.                 char        _char;                              /* character                    */
  226.                 int         _int;                               /* integer                      */
  227.                 short       _short;                             /* short                        */
  228.                 long        _long;                              /* long                         */
  229.                 int         _i;                                 /* alternate integer            */
  230.                 short       _s;                                 /* alternate short              */
  231.                 uchar       _uchar;                             /* unsigned character           */
  232.                 uint        _uint;                              /* unsigned integer             */
  233.                 ushort      _ushort;                            /* unsigned short               */
  234.                 ulong       _ulong;                             /* unsigned long                */
  235.                 void        *_p;                                /* pointer                      */
  236.                 ulong       _a;                                 /* address                      */
  237.                 s_int_08    _s_int_08;                          /* signed  8-bit integer        */
  238.                 s_int_16    _s_int_16;                          /* signed 16-bit integer        */
  239.                 s_int_32    _s_int_32;                          /* signed 32-bit integer        */
  240.                 u_int_08    _u_int_08;                          /* unsigned  8-bit integer      */
  241.                 u_int_16    _u_int_16;                          /* unsigned  8-bit integer      */
  242.                 u_int_32    _u_int_32;                          /* unsigned  8-bit integer      */
  243.                 } any;
  244.  
  245. /*
  246. **  Standard Byte Re-ordering Functions
  247. */
  248.  
  249. #define     hton_08(x)  (x)
  250. #define     hton_16(x)  (x)
  251. #define     hton_32(x)  (x)
  252.  
  253. #define     ntoh_08(x)  (x)
  254. #define     ntoh_16(x)  (x)
  255. #define     ntoh_32(x)  (x)
  256.  
  257. /*
  258. **  Boundary Alignment
  259. */
  260.  
  261.  
  262. /*
  263. **  Run-Time Assert 
  264. */
  265.  
  266. #ifndef DA
  267. #define     assert(exp)                                                  \
  268.                 if ( ! ( exp ) ) {                                       \
  269.                     printf ("assert failed: line = '%d'; file = '%s' \n",\
  270.                             _LINE_, _FILE_ );                            \
  271.                     printf ("               expression = '%s' \n",       \
  272.                              "exp" );                                    \
  273.                     ExitToShell ( );                                     \
  274.                     }
  275. #else
  276. #define     assert(exp)
  277. #endif
  278.  
  279. #ifdef NDEBUG
  280. #undef      assert
  281. #define     assert(exp)                                                  \
  282. #endif
  283.  
  284.  
  285. /*
  286. **  Compile-Time Assert - Generates "Illegal Array Bounds" error
  287. */
  288.  
  289. #ifndef NDEBUG
  290. #define     ASSERT(EXP) {struct{char a[EXP];};}
  291. #else
  292. #define     ASSERT(EXP)
  293. #endif  NDEBUG
  294.  
  295. /*
  296. **  Debugging Macros
  297. */
  298.  
  299. #ifndef DA
  300. #define snap(format,value)                                                \
  301.     {                                                                     \
  302.         unsigned char   text[256];                                        \
  303.         sprintf  ( &text, format, value );                                \
  304.         CtoPstr  ( &text );                                               \
  305.         DebugStr ( &text );                                               \
  306.     }
  307.     
  308. #else
  309. #define snap(format,value)                                                \
  310.     {                                                                     \
  311.         ParamText ( format, NULL, NULL, NULL );                           \
  312.         NoteAlert ( -15743, NULL );                                       \
  313.     }
  314. #endif
  315.  
  316. #ifdef NDEBUG
  317. #undef  snap
  318. #define snap(format,value)
  319. #endif
  320.     
  321.  
  322. /* ******************************************************************************************** */
  323. /* *                                                                                          * */
  324. /* *    The following are of dubious use...                                                   * */
  325. /* *                                                                                          * */
  326. /* ******************************************************************************************** */
  327.  
  328. /*
  329. **  Pascal and PL/I Compatability
  330. */
  331.  
  332. #define     begin       {
  333. #define     end         }
  334. #define     then    
  335.  
  336.  
  337. /* ******************************************************************************************** */
  338. /* *                                                                                          * */
  339. /* *    End of Definitions                                                                    * */
  340. /* *                                                                                          * */
  341. /* ******************************************************************************************** */
  342.  
  343. #endif  unix
  344.  
  345. #define _standard_h_
  346. #endif  _standard_h_
  347.